home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / ab20 / unarced / utilities / system / intuition / shadow / docs / glossary.doc < prev    next >
Encoding:
Text File  |  1995-03-17  |  10.9 KB  |  254 lines
  1.                        Shadow Development Documentation
  2.                             Library Version 4.6
  3.  
  4.                               By David Navas
  5.                          Updated:  09 Feb 1992
  6.  
  7.                       Copyright © 1992 by David Navas
  8.                             All Rights Reserved
  9.  
  10.  
  11.                                  GLOSSARY
  12.      ATTR_*
  13.           A reference to a particular attribute.  An object's attributes
  14.           are documented in the object's class description in the
  15.           ShadowLibMethods.doc file.
  16.  
  17.      Attribute
  18.           A variable or structure stored at a particular offset inside of
  19.           an object.  The offset and  other information about attributes
  20.           are stored in the class definition in the class->meta_attributes
  21.           field.  Attributes are qsorted by the unique string address of
  22.           the attribute (#defined as an ATTR_....)
  23.  
  24.           Attributes can also have a default object structure which is the
  25.           default value (or values for an attribute which is a structure)
  26.           that all objects containing this attribute take on.
  27.  
  28.           All attributes are created by using the AttributeTag structure
  29.           which is passed into the METHOD_META_SUB or METHOD_META_INIT
  30.           method defined for METACLASS.  Refer to the method definitions
  31.           in ShadowLibMethods.doc for documentation on these methods.
  32.  
  33.      AutoResource
  34.           An object which has been stuck on a process' ATTR_RESOURCETREE or
  35.           ATTR_RESOURCESTACK.
  36.  
  37.           The ATTR_RESOURCETREE is freed during the process'
  38.           METHOD_META_REMOVE method, the process' METHOD_META_DESTROY
  39.           method, and once at the finish of RemoveThread(), or for each
  40.           ^C received inside of RemoveThread().
  41.  
  42.           The ATTR_RESOURCESTACK is freed only at the finish of
  43.           RemoveThread().  This implies that the resources on the
  44.           ATTR_RESOURCESTACK must not reference the process, as
  45.           RemoveThread() does not get this far until there are no
  46.           references on a process' object.
  47.  
  48.           When these resources are freed, they are sent a
  49.           METHOD_META_REMOVE and are then dropped from the tree.
  50.           Notification of this removal is NOT sent.
  51.  
  52.      AVL Trees
  53.           Automatically balancing binary trees which SHADOW uses
  54.           throughout most of the system.  Two notable exceptions are: one,
  55.           the system string code, and two, the semaphore code.  While both
  56.           of these systems do store various elements on a binary tree,
  57.           they are NOT AVL trees, and, in fact, the system string code
  58.           has the right and left child pointer reversed!  ;)
  59.  
  60.           My A3000 can store and remove about 2800 objects per second from
  61.           the AVL tree subsystem.  These AVL trees are semaphored for
  62.           correct behaviour in a multi-threaded environment.
  63.           Unfortunately, because of the way SHARED semaphores work, you
  64.           may NOT own an EXCLUSIVE semaphore on the BinTree when calling
  65.           FindBinNode(), or other Find*BinNode() functions.
  66.           RecurseBinTree() uses an EXCLUSIVE semaphore as a result of this
  67.           behaviour of EXEC semaphores.  Someday this wil be fixed, and
  68.           RecurseBinTree() will go back to using SHARED semaphores.
  69.  
  70.      Binary Trees
  71.      BinTree
  72.           See: AVL Trees
  73.  
  74.      Browser
  75.           A cute class browser which allows you to see classes, meta,
  76.           methods, attributes, and instances of the objects which exist as
  77.           system elements (ie: objects which have had a METHOD_META_INIT
  78.           sent to them, but not yet a METHOD_META_REMOVE).
  79.  
  80.      Class
  81.           Used in two ways:
  82.              First, as an instance of METACLASS.
  83.              Second, as any formal description of the methods and
  84.                      attributes of an object.
  85.  
  86.           For the first, the word should be capitilized: Class.
  87.           For the second, the word should be lower-case: class,
  88.                                     and is often quoted: 'class'
  89.  
  90.      Cluster
  91.           Instance of METACLUSTER.  A description whose instances are
  92.           composites.  Describes an object (in particular, a composite)
  93.           which contains a tree of objects.  The Cluster allocates a
  94.           number of objects to reside initially on those trees when the
  95.           composite is INIT'd during the METHOD_META_INIT call.
  96.  
  97.           Probably obvious, but the Cluster keeps an array of Classes
  98.           which it instantiates and stuffs into the Composite's
  99.           ATTR_BAG binary tree.
  100.  
  101.      Composite
  102.           Instance of a Cluster.  May want to refer to the docs on the
  103.           ROOTCLUSTER (ShadowLibMethods.doc).
  104.           Has an ATTR_BAG attribute which is a binary tree where the
  105.           composite's objects are stored.
  106.  
  107.      Director
  108.           See: Watcher
  109.  
  110.      Inheritence
  111.           The process by which instances of classes gain the attributes
  112.           and methods of instances of other classes.  In the object-
  113.           oriented world, this is typically done by sub-classing
  114.           existing classes.  See sub-classing for more details.
  115.  
  116.      Meta
  117.           A 'class' which is an instance of itself, or (saying the same
  118.           thing) a meta is a class which describes itself.  This is
  119.           necessary because all classes are an object, and all objects
  120.           have a descriptive class.
  121.  
  122.           When capitilized, it usually refers to a particular meta --
  123.           like METACLASS and METACLUSTER.
  124.  
  125.      METHOD_*
  126.           A reference to a particular method.  An object's methods
  127.           are documented in the object's class description in the
  128.           ShadowLibMethods.doc file.
  129.  
  130.      Method
  131.           A function called as a function or via a message.  The function
  132.           address and other information about methods are stored in the
  133.           class definition in the class->meta_attributes field.  Methods
  134.           are qsorted by the unique string address of the method
  135.           (#defined as a METHOD_....)
  136.  
  137.           Methods can also be patched, so that one method call might
  138.           actually end up calling several different functions, in several
  139.           different ways (via a sybc. message, and via another async call,
  140.           for instance).  All of the patches on all of the methods defined
  141.           in a particular class are stored in the ATTR_PATCHEDVERBS
  142.           watched-list.
  143.  
  144.           All methods are created by using the MethodTag structure which
  145.           is passed into the METHOD_META_SUB or METHOD_META_INIT method
  146.           defined for METACLASS.  Refer to the method definitions in
  147.           ShadowLibMethods.doc for documentation on these methods.
  148.  
  149.      Notification
  150.           The process by which you receive information about changes
  151.           to Watched Variables.  See: Watcher
  152.  
  153.      Object
  154.           Used in three ways:
  155.              First, as an instance of Class.
  156.              Second, as an instance of any 'class'.
  157.              Third, as a package for data.
  158.  
  159.           For the first, the word should be capitilized: Object
  160.           For the second, the word should be lower-case: object
  161.           The third usage should be apparent.
  162.  
  163.      Object-Oriented
  164.           Please see any other book that describes object-oriented
  165.           programming.  The subject is too broad to be covered here.
  166.  
  167.      Patch
  168.           An extra function to be called when the 'patched' method is
  169.           called.  Patches are prioritized, and the normal method is
  170.           called at patch priority 0.
  171.  
  172.      Patch-Chain
  173.           The list of patches associated with a particular method in a
  174.           particular class is called a patch-chain.  The patches are
  175.           called from high priority to 0, the regular method is then
  176.           called, and then the patches with negative priority are called.
  177.  
  178.           This behaviour can be modified by the run-time behaviour of
  179.           patches.  Please see The AutoDoc describing DJM() and all the
  180.           *_BLOCK flags for more details.
  181.  
  182.      ppIPC
  183.           Pete and Peter's Inter-Process Communication library.  A very
  184.           nice port and message implementation which I use.  Thanks
  185.           guys.
  186.  
  187.      Property
  188.           See: Attribute
  189.  
  190.      Resource Tracking
  191.           There are two main types of Resource Tracking.  One is for
  192.           shared objects, and this is the best supported in SHADOW.
  193.           Please refer to the AutoDocs for UseObject() and DropObject().
  194.  
  195.           The other kind is local resource tracking (resources which go
  196.           away when a program exits).  Please refer to the AutoDocs for
  197.           AddAutoResource() and RemoveAutoResource().  Resources added
  198.           using AddAutoResource() are freed automatically when the
  199.           program exits.  You can prevent the removal by calling
  200.           RemoveAutoResource and managing the returned object yourself.
  201.  
  202.      System String
  203.           System strings are useful for constant strings.  The system
  204.           returns a unique address for a given string, thus allowing the
  205.           search for a string in, say, an array, by a simple longword
  206.           comparison, instead of using the slower strcmp() function.
  207.  
  208.      sub-classing
  209.           A sub-class is the result of calling a METHOD_META_SUB on an
  210.           existing class.  The sub-class inherits (or gains) all of the
  211.           methods and attributes of the pre-existing class, in addition to
  212.           creating the new attributes and methods that are passed as
  213.           parameters to the METHOD_META_SUB method.  These new methods and
  214.           attributes replace whatever old descriptions were in the
  215.           pre-existing class.
  216.  
  217.           Under SHADOW, attribute definitions cannot be overrided, although
  218.           the default attribute object can be.  Method definitions can
  219.           be overrided.
  220.  
  221.           The process of creating a sub-class is referred to as sub-classing.
  222.  
  223.      sub-meta
  224.           Same as a sub-class, except that the 'class' that is being
  225.           'sub-classed' is actually a meta description.
  226.  
  227.      super-class
  228.           See: sub-class.  The pre-existing class becomes the super-class of
  229.           the sub-class.
  230.  
  231.      Tags
  232.           I use this name in a slightly different manner than AmigaDOS 2.0
  233.           does.  A 'tagged' array is a NULL-long-word-terminated array
  234.           where each element is some specific size.
  235.  
  236.           For instance, the MethodTag is 24bytes, the AttributeTag is
  237.           12bytes.
  238.  
  239.           Usually, the First long-word is some kind of specifier.  In the
  240.           case of MethodTag and AttributeTag, these specifiers are pointers
  241.           to strings.
  242.  
  243.      Unique String
  244.           See: System String
  245.  
  246.      Watcher -- WatchedVariable
  247.           An object which hooks onto a WatchedValue or WatchedBinTree
  248.           or WatchedList structure, and gets notification sent to it
  249.           whenever the watched structure is modified via the *Watch*
  250.           routines.  In particular, whenever the WatcherDispatch function
  251.           is called.  Please see the AutoDocs for this and other *Watch*
  252.           functions in the ShadowLibFuncs.doc documentation file.
  253.  
  254.